public static void main(String[] args) {
  ExecutorService executor = Executors.newSingleThreadExecutor();
  executor.submit(() ->
    System.out.println("Background thread finished."));
  System.out.println("Main thread finished.");
}

ExecutorService executor = MoreExecutors.getExitingExecutorService(
  (ThreadPoolExecutor) yourExecutor);

executor.setThreadFactory(
  new ThreadFactoryBuilder().setDaemon(true))

while ((line = in.readLine()) != null) {
  try {
    // ...
  } catch (InterruptedException e) {
    e.printStackTrace(); // or ignore
  }
}

while (!Thread.currentThread().isInterrupted() && ...) {
  try {
    // ...
  } catch (InterruptedException e) {
    Thread.currentThread().interrupt();
  }
}

private static final Message POISON_PILL = new Message(-1);

while (true) {
  Message message = queue.take();
  if (POISON_PILL.equals(message)) {
    return;
  }

  // handle message here ...
}

ExecutorService executor = Executors.newFixedThreadPool(8);

while (true) {
  executor.execute(() -> {
    LOG.info(Thread.currentThread().getName() + " is working");
    Uninterruptibles.sleepUninterruptibly(1L, TimeUnit.SECONDS);

    if (i.getAndIncrement() % 4 == 0) { // inject 25% errors
      throw new RuntimeException();
    }
  });
}

pool-1-thread-1 is working
pool-1-thread-2 is working
Exception in thread "pool-1-thread-1" java.lang.RuntimeException
  at UnstoppablePool.lambda$main$0(UnstoppablePool.java:27)
pool-1-thread-4 is working
pool-1-thread-5 is working
pool-1-thread-6 is working
pool-1-thread-8 is working
Exception in thread "pool-1-thread-6" java.lang.RuntimeException
  at UnstoppablePool.lambda$main$0(UnstoppablePool.java:27)
pool-1-thread-9 is working
pool-1-thread-10 is working

new Runnable() {
  public void run() {
    try {
      // logic goes here
    } catch (Throwable e) {
      // error handling
    }
  }
}

Thread.setDefaultUncaughtExceptionHandler(
  new Thread.UncaughtExceptionHandler() {
    public void uncaughtException(Thread t, Throwable e) {
      LOG.error("Thread [" + t + "] died abruptly", e);
    }
  });

Thread.setDefaultUncaughtExceptionHandler(
  UncaughtExceptionHandlers.systemExit());

ExecutorService pool = Executors.newSingleThreadExecutor();

while (true) {
  i.getAndIncrement();
  pool.execute(() -> {
    LOG.info("Tasks in queue: " + i.get());
    LOG.info("Slow thread working...");
    Uninterruptibles.sleepUninterruptibly(5L, TimeUnit.SECONDS);
  });
}

Tasks in queue: 10406024
Slow consumer working...
java.lang.OutOfMemoryError: GC overhead limit exceeded

eshelestovich:/$ java TooManyThreads
1
2
...
2023
2024
Exception in thread "main" java.lang.OutOfMemoryError: unable to create new native thread
  at java.lang.Thread.start0(Native Method)

eshelestovich:/$ sysctl kern.num_taskthreads
kern.num_taskthreads: 2048

eshelestovich:/$ java -server -XX:+UnlockDiagnosticVMOptions
-XX:+PrintFlagsFinal -XX:+PrintCommandLineFlags
-version | grep ThreadStackSize

intx ThreadStackSize = 1024

-XX:ParallelGCThreads=8
-XX:ConcGCThreads=2

new ThreadPoolExecutor(
  8, 32,
  60L, TimeUnit.SECONDS, // keepAliveTime
  new ArrayBlockingQueue<>(1024),
  new ThreadPoolExecutor.CallerRunsPolicy()); // backpressure

Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.92-b14 mixed mode):
"pool-1-thread-32" #42 prio=5
"pool-1-thread-31" #41 prio=5
"pool-1-thread-30" #40 prio=5
"pool-1-thread-29" #39 prio=5
"pool-1-thread-28" #38 prio=5
"pool-1-thread-27" #37 prio=5
"pool-1-thread-26" #36 prio=5
...

ThreadFactory factory = new ThreadFactoryBuilder()
  .setNameFormat("my-kafka-pool-%d").build();
ExecutorService pool = Executors.newFixedThreadPool(4, factory);

private Object[] items = new Object[] {};

private ArrayCopy add(Object newItem) {
  synchronized (items) {
    Object[] newArray = new Object[items.length + 1];
    ...
    items = newArray; // lock object mutation
  }
  return this;
}

private final String lock = "LOCK";

public void doSomething() {
  synchronized (lock) { ... }
}

private final Integer lock = 42;

public void doSomething() {
  synchronized (lock) { ... }
}

private static SysCtx ctx; // static shared state

public synchronized SysCtx getSysCtx() { // two intrinsic locks
  if (ctx == null) {
    ctx = new SysCtx();
  }
  return ctx;
}

synchronized (this) {
  Future<User> user = remoteService.getUser(id); // network I/O
  // ...
}

public String getNames(StringBuffer sb) {
  sb.append("Alice");
  sb.append("Claire");
  return sb.toString();
}

public String getNames() {
  StringBuffer sb = new StringBuffer();
  sb.append("Alice");
  sb.append(someName);
  sb.append("Barbara");
  return sb.toString();
}

Lock[] locks = new ReentrantLock[16];

public User getUser(int id) {
  Lock lock = locks[id % 16];
  lock.lock();
  ...
}